package ch.penas.business.service;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import javax.faces.model.SelectItem;
import javax.persistence.Query;

import ch.penas.business.dom.Agenda;
import ch.penas.business.dom.Formateur;
import ch.penas.business.dom.RechercheFormateur;

/** @author Daniel */
public class FormateurServiceImpl extends UtilisateurAbstractMYSQL implements
             FormateurService, Serializable {

    /** Serialisation de la class pour une question de securiter. */
    private static final long serialVersionUID = -6797092500849314538L;

    /** Liste des Formateur. */
    private List<Formateur> mFormateurList;

    private Formateur tempsRechercheFormateur;

	private List<SelectItem> idFormateur;

    private boolean isTrue = true;

    private boolean loginIsTrue;

    private String testUser;

    private Formateur formateur;

	/** Constructeur par default de la classe FormateurServiceImpl. */
    public FormateurServiceImpl() {
        this.mFormateurList = new ArrayList<Formateur>();
        this.idFormateur = new ArrayList<SelectItem>();
        this.formateur = new Formateur();
    }

    /** Permet d'afficher les formateur.
     *
     * @return la liste des formateur
     */
    public final List<Formateur> getAll() {
        if (this.getIsTrue()) {
        try {
            initFixture();
        } catch (Exception e) {
            e.printStackTrace();
        }
        this.mFormateurList.removeAll(mFormateurList);
        getEntityTransaction().begin();

        Query query = getEntityManager().createQuery(
            "SELECT e FROM Formateur e ORDER BY e.idUtilisateur, e.user ASC");

        @SuppressWarnings("unchecked")
        List<Formateur> b = query.getResultList();
        for (Formateur a : b) {
            this.setFormateur(a);
            this.addRecherche(this.getFormateur());
        }
        getEntityTransaction().commit();

        try {
            closeEntityManager();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        this.setIsTrue(false);
        }
        return this.mFormateurList;
    }

    /** Permet de modifier un formateur de la base de donnée SQL.
     *
     * @param mFormateurUpd est egale a un formateur
     * a modifier de la base de donnée SQL
     */
    public final void update(final Formateur mFormateurUpd) {
    	try {
            initFixture();

            getEntityTransaction().begin();
            Formateur genre = getEntityManager().find(
            Formateur.class, mFormateurUpd.getIdUtilisateur());

            if (mFormateurUpd.getUser() != "") {
                genre.setUser(mFormateurUpd.getUser());
            }
            if (mFormateurUpd.getNom() != "") {
                genre.setNom(mFormateurUpd.getNom());
            }
            if (mFormateurUpd.getPrenom() != "") {
                genre.setPrenom(mFormateurUpd.getPrenom());
            }
            if (mFormateurUpd.getAdresse() != "") {
                genre.setAdresse(mFormateurUpd.getAdresse());
            }
            if (mFormateurUpd.getNumeroFixe() != "") {
                genre.setNumeroFixe(mFormateurUpd.getNumeroFixe());
            }
            if (mFormateurUpd.getNumeroNatel() != "") {
                genre.setNumeroNatel(
                        mFormateurUpd.getNumeroNatel());
            }
            if (mFormateurUpd.getMail() != "") {
                genre.setMail(mFormateurUpd.getMail());
            }
            if (mFormateurUpd.getPassword() != "") {
                genre.setPassword(mFormateurUpd.getPassword());
            }
            getEntityTransaction().commit();

            closeEntityManager();
            this.setIsTrue(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /** Permet d'ajouter un formateur a la base de donnée SQL.
     *
     * @param mFormateurAdd est egal a un formateur
     * a ajouter a la base de donnée SQL
     */
    public final void add(final Formateur mFormateurAdd) {
        try {
            initFixture();

            getEntityTransaction().begin();
            getEntityManager().persist(mFormateurAdd);
            getEntityTransaction().commit();

            closeEntityManager();
            this.setIsTrue(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /** Permet d'afficher le nombre de formateur existant.
     *
     * @return le nombre de formateur
     */
    public final int getNbFormateur() {
        Object resultQuery;
        try {
            initFixture();
        } catch (Exception e) {
            e.printStackTrace();
        }
        getEntityTransaction().begin();

        Query query = getEntityManager().createQuery(
                "SELECT COUNT(e.user) FROM Formateur e");

        resultQuery = query.getSingleResult();

        getEntityTransaction().commit();

        try {
            closeEntityManager();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return Integer.parseInt(resultQuery.toString());
    }

    /** Permet de supprimer un formateur de la base de donnée SQL.
     *
     * @param mFormateurDel est egale a un formateur
     * a supprimer de la base de donnée SQL
     */
    public final void del(final Formateur mFormateurDel) {
        try {
            initFixture();

            getEntityTransaction().begin();
            Formateur userx = getEntityManager().find(
            Formateur.class, mFormateurDel.getIdUtilisateur());
            getEntityManager().remove(userx);
            getEntityTransaction().commit();

            closeEntityManager();
            this.setIsTrue(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public final List<SelectItem> getValuesIdFormateur() {
    	if (this.getIsTrue()) {
    	try {
            initFixture();
        } catch (Exception e) {
            e.printStackTrace();
        }
        this.idFormateur.removeAll(this.idFormateur);
        getEntityTransaction().begin();

        Query query = getEntityManager().createQuery(
        "SELECT e FROM Formateur e WHERE e.idUtilisateur <>' 1 '"
        + "AND e.idUtilisateur <>' 2 '");

        @SuppressWarnings("unchecked")
        List<Formateur> b = query.getResultList();
        for (Formateur a : b) {
            this.formateur = a;
            this.idFormateur.add(new SelectItem(formateur.getIdUtilisateur(),
               formateur.getUser()));
        }
        getEntityTransaction().commit();

        try {
            closeEntityManager();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        this.setIsTrue(true);
        }
        return this.idFormateur;
    }

    public final void addRecherche(final Formateur sesultQuery2) {
        this.mFormateurList.add(sesultQuery2);
    }

    public final void setTestUser(final String user) {
        this.testUser = user;
    }
    public final String getTestUser() {
        return this.testUser;
    }

    public final boolean getIsTrue() {
        return isTrue;
    }
    public final void setIsTrue(final boolean aIsTrue) {
        this.isTrue = aIsTrue;
    }

    public final boolean getLoginIsTrue() {
        return loginIsTrue;
    }

    public final void setLoginIsTrue(final boolean aLoginIsTrue) {
        this.loginIsTrue = aLoginIsTrue;
    }

    public final Formateur getFormateur() {
        return this.formateur;
    }

    public void setFormateur(Formateur formateur) {
		this.formateur = formateur;
	}
    
    public Formateur getTempsRechercheFormateur() {
		return tempsRechercheFormateur;
	}
}